package com.gitee.qdbp.general.common.biz.reusable.service;

import java.util.Arrays;
import java.util.List;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import com.gitee.qdbp.able.exception.ServiceException;
import com.gitee.qdbp.able.result.ResultCode;
import com.gitee.qdbp.base.system.model.IAccount;
import com.gitee.qdbp.general.common.api.reusable.basic.IProcessingRecordBasic;
import com.gitee.qdbp.general.common.api.reusable.model.ProcessingRecordBean;
import com.gitee.qdbp.general.common.api.reusable.model.ProcessingRecordUpdate;
import com.gitee.qdbp.general.common.api.reusable.service.IProcessingRecordExecutor;
import com.gitee.qdbp.tools.utils.VerifyTools;

/**
 * 处理过程备注业务处理类
 *
 * @author zhh
 * @version 170702
 */
@Service
@Transactional(propagation = Propagation.REQUIRED, rollbackFor = Throwable.class)
public class ProcessingRecordExecutor implements IProcessingRecordExecutor {

    /** 日志对象 **/
    private static final Logger log = LoggerFactory.getLogger(ProcessingRecordExecutor.class);

    /** 处理过程备注DAO **/
    @Autowired
    private IProcessingRecordBasic processingRecordBasic;

    @Override
    public void create(ProcessingRecordBean model, IAccount me) throws ServiceException {
        String msg = "Failed to create ProcessingRecord. ";

        if (VerifyTools.isBlank(me)) {
            log.error(msg + "params is null: me");
            throw new ServiceException(ResultCode.PARAMETER_IS_REQUIRED);
        }
        if (VerifyTools.isBlank(model)) {
            log.error(msg + "params is null: model");
            throw new ServiceException(ResultCode.PARAMETER_IS_REQUIRED);
        }

        // TODO: 参数验证
        // if (VerifyTools.isBlank(model.getXxx())) {
        //     log.error(msg + "params is null: xxx");
        //     throw new ServiceException(ResultCode.PARAMETER_IS_REQUIRED);
        // }

        // 业务逻辑
        model.setId(null); // 主键由Basic生成, 不允许外部传入
        // TODO: 补充其他业务逻辑
        // 设置创建人信息
        // model.setCreatorId(me.getUserId()); // 创建人ID
        // model.setCreatorName(me.getDisplayName()); // 创建人姓名

        // 向gn_processing_record表插入记录
        processingRecordBasic.create(model);

        throw new UnsupportedOperationException("该方法的业务逻辑暂未实现"); // TODO 完成业务逻辑的实现之后删除此行
    }

    @Override
    public void update(ProcessingRecordUpdate model, IAccount me) throws ServiceException {
        String msg = "Failed to update ProcessingRecord. ";

        if (VerifyTools.isBlank(me)) {
            log.error(msg + "params is null: me");
            throw new ServiceException(ResultCode.PARAMETER_IS_REQUIRED);
        }
        if (VerifyTools.isBlank(model)) {
            log.error(msg + "params is null: model");
            throw new ServiceException(ResultCode.PARAMETER_IS_REQUIRED);
        }

        // TODO: 参数验证
        // if (VerifyTools.isBlank(model.getXxx())) {
        //     log.error(msg + "params is null: Xxx");
        //     throw new ServiceException(ResultCode.PARAMETER_IS_REQUIRED);
        // }

        String id = model.getId();
        if (VerifyTools.isBlank(id) && model.getWhere() != null) {
            id = model.getWhere().getId();
        }
        if (VerifyTools.isBlank(id)) {
            log.error(msg + "params is null: id");
            throw new ServiceException(ResultCode.PARAMETER_IS_REQUIRED);
        }

        // 原始记录检查
        ProcessingRecordBean older = processingRecordBasic.findById(id);
        if (older == null) {
            log.error(msg + "record is not found. id=" + id);
            throw new ServiceException(ResultCode.RECORD_NOT_EXIST);
        }

        // TODO: 业务逻辑
        // 判断哪些状态的记录不允许修改...
        // if (VerifyTools.isExists(older.getState(), State.DISABLED, State.Xxx)) {
        //     throw new ServiceException(ResultCode.RECORD_STATE_ERROR);
        // }

        ProcessingRecordUpdate newer = createChangedModel(model, older);

        if (newer != null) {
            // 更新gn_processing_record表的记录
            processingRecordBasic.update(newer, false);
        }

        throw new UnsupportedOperationException("该方法的业务逻辑暂未实现"); // TODO 完成业务逻辑的实现之后删除此行
    }

    @Override
    public void delete(String id, IAccount me) throws ServiceException {
        String msg = "Failed to delete ProcessingRecord. ";

        if (VerifyTools.isBlank(me)) {
            log.error(msg + "params is null: me");
            throw new ServiceException(ResultCode.PARAMETER_IS_REQUIRED);
        }
        if (VerifyTools.isBlank(id)) {
            log.error(msg + "params is null: id");
            throw new ServiceException(ResultCode.PARAMETER_IS_REQUIRED);
        }

        // 从gn_processing_record表查询原记录
        ProcessingRecordBean older = processingRecordBasic.findById(id);
        if (older == null) {
            log.error(msg + "record is not found.\n\tid is " + id);
            throw new ServiceException(ResultCode.RECORD_NOT_EXIST);
        }

        // TODO: 业务逻辑
        // 判断哪些状态的记录不允许删除...
        // if (VerifyTools.isExists(older.getState(), State.DISABLED, State.Xxx)) {
        //     throw new ServiceException(ResultCode.RECORD_STATE_ERROR);
        // }

        // 删除gn_processing_record表的记录
        processingRecordBasic.deleteByIds(Arrays.asList(id), false);

        throw new UnsupportedOperationException("该方法的业务逻辑暂未实现"); // TODO 完成业务逻辑的实现之后删除此行
    }

    @Override
    public void delete(List<String> ids, IAccount me) throws ServiceException {
        String msg = "Failed to delete ProcessingRecord. ";

        if (VerifyTools.isBlank(me)) {
            log.error(msg + "params is null: me");
            throw new ServiceException(ResultCode.PARAMETER_IS_REQUIRED);
        }
        if (VerifyTools.isBlank(ids)) {
            log.error(msg + "params is null: ids");
            throw new ServiceException(ResultCode.PARAMETER_IS_REQUIRED);
        }

        // 删除gn_processing_record表的记录
        processingRecordBasic.deleteByIds(ids, false);

        throw new UnsupportedOperationException("该方法的业务逻辑暂未实现"); // TODO 完成业务逻辑的实现之后删除此行
    }

    /**
     * 创建一个新的对象, 只包含改动过的字段
     *
     * @author zhh
     * @param model 目标对象(一般是参数传入的)
     * @param older 源对象(一般是从数据库查询得到的)
     * @return 只包含有更新的字段对象
     */
    private ProcessingRecordUpdate createChangedModel(ProcessingRecordUpdate model, ProcessingRecordBean older) {
        // ProcessingRecordUpdate newer = new ProcessingRecordUpdate();
        // newer.setWhere(model.getWhere());
        //
        // boolean changed = false;
        // newer.setId(model.getId()); // 过程ID
        //
        // if (VerifyTools.isChanged(model.getTenantCode(), older.getTenantCode())) {
        //     changed = true;
        //     newer.setTenantCode(model.getTenantCode()); // 租户编号
        // }
        // if (VerifyTools.isChanged(model.getDataType(), older.getDataType())) {
        //     changed = true;
        //     newer.setDataType(model.getDataType()); // 数据类型
        // }
        // if (VerifyTools.isChanged(model.getDataId(), older.getDataId())) {
        //     changed = true;
        //     newer.setDataId(model.getDataId()); // 数据ID
        // }
        // if (VerifyTools.isChanged(model.getDataDesc(), older.getDataDesc())) {
        //     changed = true;
        //     newer.setDataDesc(model.getDataDesc()); // 数据描述
        // }
        // if (VerifyTools.isChanged(model.getBizType(), older.getBizType())) {
        //     changed = true;
        //     newer.setBizType(model.getBizType()); // 业务类型
        // }
        // if (VerifyTools.isChanged(model.getBizCode(), older.getBizCode())) {
        //     changed = true;
        //     newer.setBizCode(model.getBizCode()); // 业务编号
        // }
        // if (VerifyTools.isChanged(model.getVisibleLevel(), older.getVisibleLevel())) {
        //     changed = true;
        //     newer.setVisibleLevel(model.getVisibleLevel()); // 可见级别:1.用户可见|2.管理员可见|3.高管可见
        // }
        // if (VerifyTools.isChanged(model.getProcessType(), older.getProcessType())) {
        //     changed = true;
        //     newer.setProcessType(model.getProcessType()); // 处理类型(0.处理|1.备注|2.结论)
        // }
        // if (VerifyTools.isChanged(model.getProcessTitle(), older.getProcessTitle())) {
        //     changed = true;
        //     newer.setProcessTitle(model.getProcessTitle()); // 处理标题
        // }
        // if (VerifyTools.isChanged(model.getProcessContent(), older.getProcessContent())) {
        //     changed = true;
        //     newer.setProcessContent(model.getProcessContent()); // 处理描述
        // }
        // if (VerifyTools.isChanged(model.getProcessState(), older.getProcessState())) {
        //     changed = true;
        //     newer.setProcessState(model.getProcessState()); // 处理状态(文字)
        // }
        // if (VerifyTools.isChanged(model.getProcessorId(), older.getProcessorId())) {
        //     changed = true;
        //     newer.setProcessorId(model.getProcessorId()); // 处理人id
        // }
        // if (VerifyTools.isChanged(model.getProcessorName(), older.getProcessorName())) {
        //     changed = true;
        //     newer.setProcessorName(model.getProcessorName()); // 处理人姓名
        // }
        // if (VerifyTools.isChanged(model.getProcessTime(), older.getProcessTime())) {
        //     changed = true;
        //     newer.setProcessTime(model.getProcessTime()); // 处理时间
        // }
        // if (VerifyTools.isChanged(model.getQueryString(), older.getQueryString())) {
        //     changed = true;
        //     newer.setQueryString(model.getQueryString()); // 查询字符串
        // }
        // if (VerifyTools.isChanged(model.getOptions(), older.getOptions())) {
        //     changed = true;
        //     newer.setOptions(model.getOptions()); // 选项
        // }
        // if (VerifyTools.isChanged(model.getDataState(), older.getDataState())) {
        //     changed = true;
        //     newer.setDataState(model.getDataState()); // 数据状态:0为正常|其他为删除
        // }
        // if (Boolean.TRUE.equals(model.isTenantCodeToNull())) {
        //     changed = true;
        //     newer.setTenantCodeToNull(true); // 租户编号更新为空值
        // }
        // if (Boolean.TRUE.equals(model.isDataTypeToNull())) {
        //     changed = true;
        //     newer.setDataTypeToNull(true); // 数据类型更新为空值
        // }
        // if (Boolean.TRUE.equals(model.isDataIdToNull())) {
        //     changed = true;
        //     newer.setDataIdToNull(true); // 数据ID更新为空值
        // }
        // if (Boolean.TRUE.equals(model.isDataDescToNull())) {
        //     changed = true;
        //     newer.setDataDescToNull(true); // 数据描述更新为空值
        // }
        // if (Boolean.TRUE.equals(model.isBizTypeToNull())) {
        //     changed = true;
        //     newer.setBizTypeToNull(true); // 业务类型更新为空值
        // }
        // if (Boolean.TRUE.equals(model.isBizCodeToNull())) {
        //     changed = true;
        //     newer.setBizCodeToNull(true); // 业务编号更新为空值
        // }
        // if (Boolean.TRUE.equals(model.isVisibleLevelToNull())) {
        //     changed = true;
        //     newer.setVisibleLevelToNull(true); // 可见级别:1.用户可见|2.管理员可见|3.高管可见更新为空值
        // }
        // if (VerifyTools.isNotBlank(model.getVisibleLevelAdd()) && model.getVisibleLevelAdd() != 0) {
        //     changed = true;
        //     newer.setVisibleLevelAdd(model.getVisibleLevelAdd()); // 可见级别:1.用户可见|2.管理员可见|3.高管可见的增加值
        // }
        // if (Boolean.TRUE.equals(model.isProcessTypeToNull())) {
        //     changed = true;
        //     newer.setProcessTypeToNull(true); // 处理类型(0.处理|1.备注|2.结论)更新为空值
        // }
        // if (Boolean.TRUE.equals(model.isProcessTitleToNull())) {
        //     changed = true;
        //     newer.setProcessTitleToNull(true); // 处理标题更新为空值
        // }
        // if (Boolean.TRUE.equals(model.isProcessContentToNull())) {
        //     changed = true;
        //     newer.setProcessContentToNull(true); // 处理描述更新为空值
        // }
        // if (Boolean.TRUE.equals(model.isProcessStateToNull())) {
        //     changed = true;
        //     newer.setProcessStateToNull(true); // 处理状态(文字)更新为空值
        // }
        // if (Boolean.TRUE.equals(model.isProcessorIdToNull())) {
        //     changed = true;
        //     newer.setProcessorIdToNull(true); // 处理人id更新为空值
        // }
        // if (Boolean.TRUE.equals(model.isProcessorNameToNull())) {
        //     changed = true;
        //     newer.setProcessorNameToNull(true); // 处理人姓名更新为空值
        // }
        // if (Boolean.TRUE.equals(model.isProcessTimeToNull())) {
        //     changed = true;
        //     newer.setProcessTimeToNull(true); // 处理时间更新为空值
        // }
        // if (Boolean.TRUE.equals(model.isProcessTimeToCurrent())) {
        //     changed = true;
        //     newer.setProcessTimeToCurrent(true); // 处理时间更新为数据库当前时间
        // }
        // if (VerifyTools.isNotBlank(model.getProcessTimeAdd()) && model.getProcessTimeAdd() != 0) {
        //     changed = true;
        //     newer.setProcessTimeAdd(model.getProcessTimeAdd()); // 处理时间的增加值
        // }
        // if (Boolean.TRUE.equals(model.isQueryStringToNull())) {
        //     changed = true;
        //     newer.setQueryStringToNull(true); // 查询字符串更新为空值
        // }
        // if (Boolean.TRUE.equals(model.isOptionsToNull())) {
        //     changed = true;
        //     newer.setOptionsToNull(true); // 选项更新为空值
        // }
        // return changed ? newer : null;

        throw new UnsupportedOperationException("请确认ProcessingRecordUpdate哪些字段是允许修改的"); // TODO 完成业务逻辑的实现之后删除此行
    }

}